////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file camxoisdata.h
/// @brief ois driver data
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef CAMXOISDATA_H
#define CAMXOISDATA_H

#include "camxcslsensordefs.h"
#include "camxdefs.h"
#include "camxhal3defs.h"
#include "camxsensorproperty.h"
#include "camxtypes.h"
#include "camxoisdriver.h"

CAMX_NAMESPACE_BEGIN


/// @brief PositionUnit
enum class OISMode
{
    EnableOIS,          ///< Enable mode
    DisableOIS,         ///< Disable mode
    Movie,              ///< Movie mode
    Still,              ///< Still mode
    EnterDownLoadMode,  ///< Force OIS into download mode
    CenteringOn,        ///< Center On mode
    CenteringOff,       ///< Center Off mode
    Pantilt,            ///< Pantilt mode
    Scene,              ///< Scene mode
    SceneFilterOn,      ///< Scene Filter On mode
    SceneFilterOff,     ///< Scene Filter Off mode
    SceneRangeOn,       ///< Scene Range on mode
    SceneRangeOff,      ///< Scene Range off mode
    ModeEnd,            ///< End of enum
};


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Class containing Ois APIs
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class OISData
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// OISData
    ///
    /// @brief  Constructor
    ///
    /// @param  pOisDriverData    Pointer to OIS driver data
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    explicit OISData(
        OISDriverData* pOisDriverData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~OISData
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ~OISData();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CalibrateOISDriverData
    ///
    /// @brief  Calibrates the OIS with the OTP data obtained from OIS driver
    ///
    ///
    /// @return Success or failure
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CalibrateOISDriverData() const;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateI2CInfoCmd
    ///
    /// @brief  Create I2C Info command
    ///
    /// @param  pI2CInfoCmd I2CInfo command
    ///
    /// @return CamxResultSuccess, if SUCCESS
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateI2CInfoCmd(
        CSLOISI2CInfo* pI2CInfoCmd);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetPowerSequenceCmdSize
    ///
    /// @brief  Get size for power up/down command buffer
    ///
    /// @param  isPowerUp   Is it power up or power down
    ///
    /// @return Size of the command buffer
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT GetPowerSequenceCmdSize(
        BOOL isPowerUp);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreatePowerSequenceCmd
    ///
    /// @brief  Create power sequence commands
    ///
    /// @param  isPowerUp   Is it power up or power down
    /// @param  pCmdBuffer  Power up/down command
    ///
    /// @return CamxResultSuccess, if SUCCESS
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreatePowerSequenceCmd(
        BOOL    isPowerUp,
        VOID*   pCmdBuffer);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetInitializeCmdSize
    ///
    /// @brief  Get size for init command buffer
    ///
    /// @return Size of the command buffer
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT GetInitializeCmdSize();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateCalibrationCmd
    ///
    /// @brief  Create calibration commands to load register settings. It is one-time execution at node initialization.
    ///
    /// @param  pCmdBuffer  init I2C command
    ///
    /// @return CamxResultSuccess, if SUCCESS
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateCalibrationCmd(
        VOID*   pCmdBuffer);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetCalibrationCmdSize
    ///
    /// @brief  Get size for calibration command buffer
    ///
    /// @return Size of the command buffer
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT GetCalibrationCmdSize();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateInitializeCmd
    ///
    /// @brief  Create initialize commands to load init register settings. It is one-time execution at node initialization.
    ///
    /// @param  pCmdBuffer  init I2C command
    ///
    /// @return CamxResultSuccess, if SUCCESS
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateInitializeCmd(
        VOID*   pCmdBuffer);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateOISModeCmd
    ///
    /// @brief  Create mode command for Ois
    ///
    /// @param  pCmdBuffer         Mode I2C command
    /// @param  mode               Ois Mode
    ///
    /// @return CamxResultSuccess, if SUCCESS
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    CamxResult CreateOISModeCmd(
        VOID*   pCmdBuffer, OISMode mode);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOISModeCmdSize
    ///
    /// @brief  Get the command buffer size of the OIS mode supported
    ///
    /// @param  mode               Ois Mode
    ///
    /// @return command size
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    UINT GetOISModeCmdSize(
        OISMode mode);
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOISModeMaxCmdSize
    ///
    /// @brief  Get the max command buffer size need to be allocated for OIS mode
    ///
    /// @return command size
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    UINT GetOISModeMaxCmdSize();
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetOISLibrary
    ///
    /// @brief  Retrieve the ois library
    ///
    /// @return ois data object at index or NULL
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    CAMX_INLINE const OISDriverData* GetOISLibrary()
    {
        return m_pOisDriverData;
    }

    const SettingsInfo* m_pCalibSettings;           ///< Pointer to calibration settings

private:
    OISData(const OISData&) = delete;               ///< Disallow the copy constructor
    OISData& operator=(const OISData&) = delete;    ///< Disallow assignment operator

    OISDriverData* m_pOisDriverData; ///< Ois driver data pointer
};

CAMX_NAMESPACE_END

#endif // CAMXOISDATA_H
